home *** CD-ROM | disk | FTP | other *** search
/ Shareware Grab Bag / Shareware Grab Bag.iso / 090 / cmln0985.arc / ARITH.LTG < prev    next >
Text File  |  1986-02-27  |  5KB  |  190 lines
  1.  
  2.  
  3.                     High-Precision Arithmetic
  4.  
  5.                             Listings
  6.  
  7.  
  8.  
  9.  
  10.                             Listing 1
  11.  
  12. multiply(array, factor)
  13. /* multiplies large number in array by factor */
  14. int     *array, factor;
  15. {
  16.         int     carry, product, i, size;
  17.         carry = 0; 
  18.         size = array[0];
  19.         for (i = 1; i <= size; i++) {
  20.                 product = factor * array[i] + carry;
  21.                 array[i] = product % 10000;
  22.                 carry = product / 10000; 
  23.         }
  24.         if (carry) 
  25.                 array [array[0] = size+1] = carry;
  26. }
  27.  
  28.  
  29. divide(array, divisor)
  30. /* divides large number in array by divisor */
  31. int     *array, divisor;
  32. {
  33.         int     remainder, term, i, size;
  34.         remainder = 0; 
  35.         size = array[0];
  36.         for (i = size; i >= 1; i--) {
  37.                 term = 10000 * remainder + array[i] ;
  38.                 array[i] = term / divisor;
  39.                 remainder = term % divisor; 
  40.         }
  41.         if (array[size] == 0) 
  42.                 array [0] = size - 1;
  43. }
  44.  
  45.  
  46. add(sumarray, termarray)
  47. /* adds termarray into sumarray */
  48. int     *sumarray, *termarray;
  49. {
  50.         int     carry, sum, i, size;
  51.         carry = 0;
  52.         if (sumarray[0] < termarray[0]) 
  53.                 size = termarray[0];
  54.         else 
  55.                 size = sumarray[0];è        for (i = 1; i <= size; i++) {
  56.                 sum = termarray[i] + sumarray[i] + carry;
  57.                 sumarray[i] = sum % 10000;
  58.                 carry = sum / 10000; 
  59.         }
  60.         if (carry) 
  61.                 sumarray [sumarray[0] = size+1] = carry;
  62. }
  63.  
  64.  
  65. subtract(diffarray, termarray)
  66. /* subtracts termarray from diffarray */
  67. int     *diffarray, *termarray;
  68. {
  69.         int     borrow, diff, i, size;
  70.         borrow = 0; 
  71.         size = diffarray[0];
  72.         for (i = 1; i <= size; i++) {
  73.                 diff = diffarray[i] - termarray[i] + borrow;
  74.                 borrow = diff / 10000;
  75.                 diffarray[i] = diff % 10000;
  76.                 /* kludge needed because a % b is not a true mod */
  77.                 if (diffarray[i] < 0) {
  78.                         diffarray[i] += 10000; 
  79.                         borrow--;
  80.                 }
  81.         }
  82.         /* difference may be much smaller than either term */
  83.         while ((diffarray[size] == 0) && (size > 0))
  84.                 diffarray[0] = size--;
  85. }
  86.  
  87.  
  88.                             Listing 2
  89.  
  90. #include "arith.c"
  91. #include <stdio.h>
  92. main()
  93. /* program to compute and print 2^11213-1 */
  94. {
  95.         int     d[900], f, j, size;
  96.         for (j = 1; j < 900; j++)
  97.                 d[j] = 0;
  98.         d[1] = 128;
  99.         f = 8192;
  100.         d[0] = 1;
  101.         for (j = 0; j < 862; j++)
  102.                 multiply(d, f);
  103.         d[1]--;
  104.         size = d[0];
  105.         for (j = size; j > 0; j--)
  106.                 printf("%d\n", d[j]); 
  107. }
  108.  
  109. è
  110.  
  111.                             Listing 3
  112.  
  113. #include "arith.c"
  114. #include <stdio.h>
  115. main()
  116. /* program to compute and print e to 100 places */
  117. {
  118.         int     e[27], t[27], i, f, size;
  119.         for ( i = 1; i < 27; i++) 
  120.                 e[i] = t[i] = 0;
  121.         e[26] = 2000; 
  122.         t[26] = 1000; 
  123.         f = 2; 
  124.         size = 26;
  125.         e[0] = t[0] = size;
  126.         do
  127.          {
  128.                 divide(t, f);
  129.                 add(e, t);
  130.                 f++; 
  131.         } while (t[0] > 0);
  132.         for (i = size; i > 0; i--)
  133.                 printf("%d\n", e[i]); 
  134. }
  135.  
  136.  
  137.  
  138.  
  139.                             Listing 4
  140.  
  141. #include "arith.c"
  142. #include <stdio.h>
  143.  
  144. series(array, f, size)
  145. int     *array, f, size;
  146. {
  147.         int     power[100], temp[100], sign, divisor, i;
  148.         /* set power equal to 1/f */
  149.         for ( i = 1; i < size; i++) 
  150.                 power[i] = 0;
  151.         power[size] = 1000; 
  152.         power[0] = size;
  153.         divide(power, f);
  154.         sign = 1; 
  155.         divisor = 3;
  156.         for ( i = 0; i <= size; i++) 
  157.                 array[i] = power[i];
  158.         do
  159.          {
  160.                 divide(power, f * f); 
  161.                 sign = -sign;
  162.                 for ( i = 0; i <= size; i++) 
  163.                         temp[i] = power[i];è                divide(temp, divisor); 
  164.                 divisor += 2;
  165.                 if (sign > 0)
  166.                         add(array, temp);
  167.                 else 
  168.                         subtract(array, temp);
  169.         } while ( temp[0] > 0);
  170. }
  171.  
  172.  
  173. main()
  174. /* program to compute and print pi to 100 decimal places */
  175. {
  176.         int     pi[27], partial[27], i, f, size;
  177.         size = 26;
  178.         series(pi, 5, size);           /* pi = ATAN(1/5)             */
  179.         multiply(pi, 4);               /* pi = pi * 4                */
  180.         series(partial, 239, size);    /* partial = ATAN(1/239)      */
  181.         subtract(pi, partial);         /* pi = (pi - partial)        */
  182.         multiply(pi, 4);               /* pi = (pi * 4)              */
  183.         for (i = size; i > 0; i--)
  184.                 printf("%d\n", pi[i]); 
  185. }
  186.  
  187.  
  188.  
  189.  
  190.